#集合（set）是一个无序的不重复元素序列
a = {1,2,3}

set('value')
print(a)
print(set('value'))

print('---------------------------------')#创建集合
s1 = {1,2,3,4,'w','a','w',2,4,}
print(s1)# 会去重

set('qwer1t21')
print(set('qwer1t21'))
b=set()
print(b)

print('---------------------------------')#集合的运算
# 交集 &
# 并集 |
# 补集（差集） -
# 对称补集 ^
# 子集 <
# 超集（父集） >
s = {1,2,3,4,5}
s2 = {3,4,5,6,7}

# & 交集运算
result = s & s2 # {3, 4, 5}

# | 并集运算
result1 = s | s2 # {1,2,3,4,5,6,7}

# - 差集
result2 = s - s2 # {1, 2}

# ^ 对称补集(异或集) 获取只在一个集合中出现的元素
result3 = s ^ s2 # {1, 2, 6, 7}

# <= 检查一个集合是否是另一个集合的子集
# 如果a集合中的元素全部都在b集合中出现，那么a集合就是b集合的子集，b集合是a集合超集
a = {1,2,3}
b = {1,2,3,4,5}

result4 = a <= b # True
result5 = {1,2,3} <= {1,2,3} # True
result6 = {1,2,3,4,5} <= {1,2,3} # False

# < 检查一个集合是否是另一个集合的真子集
# 如果超集b中含有子集a中所有元素，并且b中还有a中没有的元素，则b就是a的真超集，a是b的真子集
result7 = {1,2,3} < {1,2,3} # False
result8 = {1,2,3} < {1,2,3,4,5} # True

# >= 检查一个集合是否是另一个的超集
# > 检查一个集合是否是另一个的真超集
result9 = {1,2,3} >= {1,2,3} # True
result10 = {1,2,3} > {1,2,3} # False
result11 = {1,2,3,4,5} > {1,2,3} # True


print('------------------------------')#集合方法
#add 向集合中添加元素
s = {1, 2, 3, 4, 5, 6}
s.add("s7")
print(s)

#clear清空集合
s.clear()
print(s)

#返回集合的浅拷贝
s1 = {1, 2, 3, 4, 5, 6}
print(s1.copy())
# 浅拷贝创建一个新的对象，但是新对象中的元素是对原对象元素的引用。也就是说，浅拷贝只复制对象的一层结构，如果原对象中的元素是可变对象（如列表、字典等），那么浅拷贝后的新对象和原对象会共享这些可变对象

#pop删除并返回任意集合元素（如果集合为空，会引发KeyError）
s1.pop()
print(s1)

#remove 删除集合中的一个元素（如果元素不存在，会引发 KeyError）
s1.remove(4)
print(s1)

#discard 删除集合中的一个元素（如果元素不存在，则不执行任何操作）
s1.discard(3)
print(s1)

#intersection 将两个集合的交集作为一个新集合返回
s2 = {1, 2, 3, 4, 5, 6}
s3 = {3, 4, 5, 6, 7, 8}
s4 = s2.intersection(s3)
print(s4)
print(s2&s3)#效果相同

#union 将集合的并集作为一个新集合返回
s2 = {1, 2, 3, 4, 5, 6}
s3 = {3, 4, 5, 6, 7, 8}
s4 = s2.union(s3)
print(s4)
print(s2|s3)#效果相同

#difference 将两个或多个集合的差集作为一个新集合返回
s2 = {1, 2, 3, 4, 5, 6}
s3 = {3, 4, 5, 6, 7, 8}
s4 = s2.difference(s3)
print(s4)
print(s2 - s3)

#symmetric_difference 将两个集合的对称差作为一个新集合返回(两个集合合并删除相同部分，其余保留)　
s2 = {1, 2, 3, 4, 5, 6}
s3 = {3, 4, 5, 6, 7, 8}
s4 = s2.symmetric_difference(s3)
print(s4)
print(s2 ^ s3)

#update 用自己和另一个的并集来更新这个集合
s = {'p', 'y'}
s.update(['t', 'h', 'o', 'n']) # 添加多个元素
print(s)
s.update(['H', 'e'], {'l', 'l', 'o'})  # 添加列表和集合
print(s)

#intersection_update()  用自己和另一个的交集来更新这个集合
s = {'a', 'b', 'c', 'd', 'q'}
s2 = {'c', 'd', 'e', 'f'}
s.intersection_update(s2)   # 相当于s = s - s2
print(s)

#isdisjoint() 　如果两个集合有一个空交集，返回 True
s = {1, 2}
s1 = {3, 4}
s2 = {2, 3}
s.isdisjoint(s1)  # s  和 s1 两个集合的交集为空返回 True
print(s)
s.isdisjoint(s2)
print(s)

#issubset()　如果另一个集合包含这个集合，返回 True
s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s2 = {2, 3}
s.issubset(s1)# 因为 s1 集合 包含 s 集合s.issubset(s2)
print(s)

#issuperset() 　如果这个集合包含另一个集合，返回 True
s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s5 = {2, 3}
s.issuperset(s1)# s 集合不包含 s1 集合
print(s)
s.issuperset(s5)
print(s)

#difference_update() 从这个集合中删除另一个集合的所有元素
s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s3 = {2, 3}
s.difference_update(s2)# s2中的2,3   s集合中也有2,3  所以保留1
print(s)
s1.difference_update(s3)
print(s1)

#symmetric_difference_update() 用自己和另一个的对称差来更新这个集合
s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s2 = {2, 3}
s1.symmetric_difference_update(s)
print(s1)
s1.symmetric_difference_update(s2)
print(s1)
s.symmetric_difference_update(s2)
print(s)




